// 游戏常量
const CELL_SIZE = 40; // 增加单元格大小
const ROWS = 15; // 减少行数
const COLS = 20; // 减少列数，但保持地图宽度比例
const BASE_PACMAN_SPEED = 1.8; // 降低吃豆人速度，使其更难吃到豆子
const BASE_GHOST_SPEED = 8.0;  // 降低幽灵基础速度，使控制更精确
const GAME_TIME = 60;          // 游戏时间30秒
const SCORE_THRESHOLD = 1000;  // 得分阈值，达到此值显示恭喜窗口

// 游戏状态变量
let gameScale = 1;  // 游戏缩放比例
let isFullScreen = false;  // 是否全屏

// 图像资源管理
const IMAGES = {
    loaded: false,
    pacman: {
        right: null,
        left: null,
        up: null,
        down: null,
        powered: null
    },
    ghost: {
        right: null,
        left: null,
        up: null,
        down: null,
        frozen: null
    },
    beans: {
        normal: null,
        power: null
    },
    wall: null, // 添加墙壁图片
    useCustomArt: true // 默认使用自定义美术资源
};

// 预加载图像资源
function preloadImages() {
    // 检查assets/images目录中是否存在自定义图像
    const imageFiles = [
        'pacman_right.png', 'pacman_left.png', 'pacman_up.png', 'pacman_down.png', 'pacman_powered.png',
        'ghost_right_ff0000.png', 'ghost_left_ff0000.png', 'ghost_up_ff0000.png', 'ghost_down_ff0000.png', 'ghost_frozen_ff0000.png',
        'bean.png', 'power_bean.png',
        'wall.png'
    ];
    
    let loadedCount = 0;
    const totalImages = imageFiles.length;
    
    // 尝试加载每个图像
    imageFiles.forEach(filename => {
        const img = new Image();
        img.onload = () => {
            loadedCount++;
            console.log(`加载图像: ${filename} (${loadedCount}/${totalImages})`);
            
            // 根据文件名分配到正确的对象
            if (filename.startsWith('pacman_')) {
                const direction = filename.replace('pacman_', '').replace('.png', '');
                IMAGES.pacman[direction] = img;
            } else if (filename.startsWith('ghost_')) {
                const parts = filename.replace('.png', '').split('_');
                const direction = parts[1];
                IMAGES.ghost[direction] = img;
            } else if (filename === 'bean.png') {
                IMAGES.beans.normal = img;
            } else if (filename === 'power_bean.png') {
                IMAGES.beans.power = img;
            } else if (filename === 'wall.png') {
                IMAGES.wall = img;
            }
            
            // 当所有图像加载完成时
            if (loadedCount === totalImages) {
                IMAGES.loaded = true;
                console.log('所有自定义图像加载完成！');
            }
        };
        
        img.onerror = () => {
            loadedCount++;
            console.log(`图像未找到: ${filename}, 将使用默认绘制方法`);
            
            // 当所有图像检查完成时
            if (loadedCount === totalImages) {
                console.log('部分自定义图像可能未找到，但将继续使用已加载的图像');
                IMAGES.loaded = true;
            }
        };
        
        img.src = `assets/images/${filename}`;
    });
}

// 游戏状态
let gameRunning = false;
let score = 0;                 // 总得分
let currentGameScore = 0;      // 当前游戏得分
let beansCount = 0;
let initialBeansCount = 0;     // 记录初始豆子数量
let gameMap = [];
let pacman = {};
let ghost = {};
let beans = [];
let powerBeans = []; // 特殊大豆子
let isPowered = false; // 吃豆人是否处于强化状态
let powerTimer = null; // 强化状态计时器
let ghostFreezeTimer = null; // 幽灵冻结计时器
let gameTimer = GAME_TIME;     // 游戏计时器
let timerInterval = null;      // 计时器间隔
let lastKeyPressTime = 0;      // 上次按键时间，用于提高幽灵响应速度
let gameLoopId = null;         // 存储requestAnimationFrame的ID
let congratsShown = false;     // 是否已显示恭喜窗口

// 吃豆人死亡和重生相关状态
let pacmanDying = false;       // 吃豆人是否正在死亡
let pacmanLocked = false;      // 吃豆人是否被锁定
let pacmanRespawning = false;  // 吃豆人是否正在重生
let deathAnimationTimer = null; // 死亡动画计时器
let lockTimer = null;          // 锁定计时器
let respawnBlinkTimer = null;  // 重生闪烁计时器
let pacmanVisible = true;      // 控制闪烁效果中的可见性

// 添加变量跟踪被吃掉的豆子总数
let totalEatenBeans = 0;

// 获取DOM元素
let canvas = document.getElementById('gameCanvas');
let ctx;
let startButton, restartButton, gameOverElement, beansCountElement, scoreElement;
let finalScoreElement, congratsMessageElement, congratsCloseButton;

// 在文档加载完成后初始化
document.addEventListener('DOMContentLoaded', function() {
    console.log("DOM加载完成，开始初始化游戏");
    
    // 重新获取canvas元素
    canvas = document.getElementById('gameCanvas');
    if (!canvas) {
        console.error("找不到canvas元素!");
        return;
    }
    
    ctx = canvas.getContext('2d');
    if (!ctx) {
        console.error("无法获取canvas上下文!");
        return;
    }
    
    // 设置固定的画布大小，与HTML中保持一致，但根据新的CELL_SIZE调整
    canvas.width = COLS * CELL_SIZE;  // 800
    canvas.height = ROWS * CELL_SIZE; // 600
    // 设置画布背景色为白色
    canvas.style.backgroundColor = '#FFFFFF';
    
    console.log("Canvas初始化完成，尺寸:", canvas.width, "x", canvas.height);
    
    // 获取其他DOM元素
    startButton = document.getElementById('startButton');
    restartButton = document.getElementById('restartButton');
    gameOverElement = document.getElementById('gameOver');
    beansCountElement = document.getElementById('beans-count');
    scoreElement = document.getElementById('score');
    finalScoreElement = document.getElementById('finalScore');
    congratsMessageElement = document.getElementById('congratsMessage');
    congratsCloseButton = document.getElementById('congratsCloseButton');
    
    // 初始化游戏
    initGame();
    initEventListeners();
    
    // 初始调整大小
    setTimeout(resizeGame, 100);
});

// 基础地图模板 (0: 空地, 1: 墙壁, 2: 豆子位置, 3: 大豆子位置)
// 使用更少的网格单位，但保持迷宫的整体结构
const baseMapTemplate = [
    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
    [1,0,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,0,1,1],
    [1,2,1,1,2,1,1,2,1,1,1,1,2,1,1,2,1,2,1,1],
    [1,2,1,3,2,2,1,2,2,2,2,2,2,1,2,2,3,2,1,1],
    [1,2,2,2,1,2,1,1,1,1,1,1,1,1,2,1,2,2,1,1],
    [1,2,1,2,2,2,2,2,2,0,0,2,2,2,2,2,2,2,1,1],
    [1,2,1,1,2,1,1,1,0,0,0,0,1,1,1,2,1,1,1,1],
    [1,2,2,2,2,1,2,2,2,2,2,2,2,2,1,2,2,2,2,1],
    [1,1,1,1,2,1,1,1,0,0,0,0,1,1,1,2,1,1,1,1],
    [1,2,1,2,2,2,2,2,2,0,0,2,2,2,2,2,2,2,1,1],
    [1,2,2,2,1,2,1,1,1,1,1,1,1,1,2,1,2,2,1,1],
    [1,2,1,3,2,2,1,2,2,2,2,2,2,1,2,2,3,2,1,1],
    [1,2,1,1,2,1,1,2,1,1,1,1,2,1,1,2,1,2,1,1],
    [1,0,2,2,2,2,2,2,1,1,1,1,2,2,2,2,2,0,1,1],
    [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
];

// 生成结构化随机地图
function generateRandomMap() {
    // 复制基础地图模板
    const newMap = JSON.parse(JSON.stringify(baseMapTemplate));
    
    // 随机修改一些墙壁和通道，但保持整体结构
    for (let row = 1; row < baseMapTemplate.length - 1; row++) {
        for (let col = 1; col < baseMapTemplate[0].length - 1; col++) {
            // 保持边界和基本结构
            if (row <= 1 || row >= baseMapTemplate.length - 2 || col <= 1 || col >= baseMapTemplate[0].length - 2) continue;
            if (newMap[row][col] === 3) continue; // 保留大豆子位置
            
            // 在十字路口处添加豆子
            if ((row % 2 === 1 && col % 2 === 1) && newMap[row][col] !== 1) {
                newMap[row][col] = 2;
                continue;
            }
            
            // 随机修改一些墙壁和通道，但保持一定的概率
            if (newMap[row][col] === 1) {
                // 20%的概率将墙壁变为通道
                if (Math.random() < 0.2) {
                    newMap[row][col] = 2;
                }
            } else if (newMap[row][col] === 0) {
                // 空地有70%的概率变为豆子
                if (Math.random() < 0.7) {
                    newMap[row][col] = 2;
                }
            }
        }
    }
    
    // 确保吃豆人和幽灵的起始位置及周围是空地
    // 吃豆人位置及周围 (中间偏下)
    const pacmanStartRow = Math.floor(baseMapTemplate.length * 0.7);
    const pacmanStartCol = Math.floor(baseMapTemplate[0].length / 2);
    for (let r = pacmanStartRow - 1; r <= pacmanStartRow + 1; r++) {
        for (let c = pacmanStartCol - 1; c <= pacmanStartCol + 1; c++) {
            if (r >= 0 && r < baseMapTemplate.length && c >= 0 && c < baseMapTemplate[0].length) {
                if (newMap[r][c] === 1) { // 如果是墙，改为豆子
                    newMap[r][c] = 2;
                }
            }
        }
    }
    newMap[pacmanStartRow][pacmanStartCol] = 0; // 吃豆人起始位置设为空地
    
    // 幽灵位置及周围 (左上角)
    const ghostStartRow = 1;
    const ghostStartCol = 1;
    for (let r = ghostStartRow - 1; r <= ghostStartRow + 1; r++) {
        for (let c = ghostStartCol - 1; c <= ghostStartCol + 1; c++) {
            if (r >= 0 && r < baseMapTemplate.length && c >= 0 && c < baseMapTemplate[0].length) {
                if (newMap[r][c] === 1) { // 如果是墙，改为空地
                    newMap[r][c] = 0;
                }
            }
        }
    }
    newMap[ghostStartRow][ghostStartCol] = 0; // 幽灵起始位置设为空地
    
    // 确保地图的连通性
    ensureConnectivity(newMap);
    
    return newMap;
}

// 确保地图的连通性
function ensureConnectivity(map) {
    // 使用简单的算法确保主要路径是连通的
    for (let row = 1; row < map.length - 1; row += 2) {
        for (let col = 1; col < map[0].length - 1; col++) {
            if (map[row][col] === 1 && Math.random() < 0.4) {
                map[row][col] = 2; // 40%概率将墙壁变为豆子
            }
        }
    }
    
    for (let col = 1; col < map[0].length - 1; col += 2) {
        for (let row = 1; row < map.length - 1; row++) {
            if (map[row][col] === 1 && Math.random() < 0.4) {
                map[row][col] = 2; // 40%概率将墙壁变为豆子
            }
        }
    }
}

// 初始化游戏
function initGame() {
    // 保存当前游戏状态
    const wasGameRunning = gameRunning;
    
    // 重置游戏状态
    gameRunning = false;
    gameOver = false;
    
    // 只有在非游戏开始时才显示游戏封面
    if (!wasGameRunning) {
        const gameCover = document.getElementById('gameCover');
        if (gameCover) {
            gameCover.style.display = 'block';
            console.log("游戏初始化：显示封面图片 - 直接设置display:block");
        }
    } else {
        console.log("游戏开始初始化：不显示封面图片");
    }
    
    // 预加载图像资源
    preloadImages();
    
    // 不重置总得分，只重置当前游戏得分
    currentGameScore = 0;      // 重置当前游戏得分
    beansCount = 0;
    initialBeansCount = 0;
    totalEatenBeans = 0;       // 重置被吃掉的豆子总数
    
    // 重置强化状态
    isPowered = false;
    if (powerTimer) clearTimeout(powerTimer);
    if (ghostFreezeTimer) clearTimeout(ghostFreezeTimer);
    
    // 重置吃豆人状态
    pacmanDying = false;
    pacmanRespawning = false;
    pacmanVisible = true;
    
    // 重置游戏地图和豆子
    gameMap = [];
    beans = [];
    powerBeans = []; // 清空大豆子数组
    gameTimer = GAME_TIME; // 重置游戏时间
    
    // 清除之前的计时器和动画帧
    if (deathAnimationTimer) clearTimeout(deathAnimationTimer);
    if (lockTimer) clearTimeout(lockTimer);
    if (respawnBlinkTimer) clearInterval(respawnBlinkTimer);
    
    if (timerInterval) {
        clearInterval(timerInterval);
        timerInterval = null;
    }
    
    if (gameLoopId) {
        cancelAnimationFrame(gameLoopId);
        gameLoopId = null;
    }
    
    // 生成随机地图
    gameMap = generateRandomMap();
    
    // 初始化豆子和大豆子
    for (let row = 0; row < gameMap.length; row++) {
        for (let col = 0; col < gameMap[0].length; col++) {
            if (gameMap[row][col] === 2) {
                beans.push({
                    x: col * CELL_SIZE + CELL_SIZE / 2,
                    y: row * CELL_SIZE + CELL_SIZE / 2,
                    active: true
                });
                beansCount++;
                initialBeansCount++;
            } else if (gameMap[row][col] === 3) {
                // 添加大豆子
                powerBeans.push({
                    x: col * CELL_SIZE + CELL_SIZE / 2,
                    y: row * CELL_SIZE + CELL_SIZE / 2,
                    active: true
                });
                // 大豆子不计入普通豆子数量
            }
        }
    }
    
    // 初始化吃豆人 (中间偏下位置)
    const pacmanStartRow = 8; // 调整为新地图的中间偏下位置
    const pacmanStartCol = 10; // 调整为新地图的中间位置
    pacman = {
        x: pacmanStartCol * CELL_SIZE + CELL_SIZE / 2,
        y: pacmanStartRow * CELL_SIZE + CELL_SIZE / 2,
        direction: 'left',
        nextDirection: 'left',
        speed: BASE_PACMAN_SPEED,
        radius: CELL_SIZE / 2 * 1.2, // 放大吃豆人半径，原来是CELL_SIZE / 2 - 1
        mouthOpen: 0.2,
        mouthDir: 0.1,
        powered: false,
        stuckTimer: 0 // 添加停顿计时器
    };
    
    // 初始化幽灵 (玩家控制, 初始位置在左上角)
    ghost = {
        x: 1 * CELL_SIZE + CELL_SIZE / 2,
        y: 1 * CELL_SIZE + CELL_SIZE / 2,
        direction: 'right',
        speed: BASE_GHOST_SPEED,
        color: '#f44336', // 浅色系红色幽灵
        frozen: false,    // 是否被冻结
        lastX: 0,         // 上一帧的X位置，用于检测卡住
        lastY: 0,         // 上一帧的Y位置，用于检测卡住
        stuckCounter: 0,  // 卡住计数器
        lastDirection: 'right' // 上一次的移动方向
    };
    
    // 确保吃豆人和幽灵的位置是空地
    gameMap[pacmanStartRow][pacmanStartCol] = 0;
    gameMap[1][1] = 0;
    
    // 更新UI
    updateUI();
    
    // 确保倒计时显示正确
    const timerElement = document.getElementById('timer');
    if (timerElement) {
        timerElement.textContent = gameTimer;
        timerElement.style.color = '#FF0000';
    }
    
    // 输出调试信息
    console.log("初始化完成 - 吃豆人位置:", pacman.x, pacman.y, "幽灵位置:", ghost.x, ghost.y);
}

// 更新UI元素
function updateUI() {
    beansCountElement.textContent = totalEatenBeans; // 显示被吃掉的豆子总数
    scoreElement.textContent = score;
    
    // 检查是否达到得分阈值
    if (score >= SCORE_THRESHOLD && !congratsShown) {
        showCongratsMessage();
    }
}

// 绘制游戏
function drawGame() {
    // 清空画布
    ctx.clearRect(0, 0, canvas.width, canvas.height);
    
    // 绘制背景
    ctx.fillStyle = '#FFFFFF';
    ctx.fillRect(0, 0, canvas.width, canvas.height);
    
    try {
        // 绘制墙壁
        drawWalls();
        
        // 绘制豆子
        drawBeans();
        
        // 绘制大豆子
        drawPowerBeans();
        
        // 绘制幽灵
        drawGhost();
        
        // 绘制吃豆人或死亡动画
        if (pacmanDying) {
            // 绘制死亡动画
            drawPacmanDeath();
            
            // 更新死亡进度
            pacman.deathProgress = Math.min(1, (pacman.deathProgress || 0) + 0.02);
        } else if (!pacmanRespawning || pacmanVisible) {
            // 正常绘制吃豆人
            drawPacman();
        }
        
        // 如果游戏暂停但不是游戏结束，显示暂停信息
        if (!gameRunning && !gameOver) {
            ctx.fillStyle = 'rgba(0, 0, 0, 0.5)';
            ctx.fillRect(0, 0, canvas.width, canvas.height);
            
            ctx.fillStyle = '#FFFFFF';
            ctx.font = '30px Arial';
            ctx.textAlign = 'center';
            ctx.fillText('游戏暂停', canvas.width / 2, canvas.height / 2);
        }
        
        // 添加调试信息
        console.log("绘制游戏完成");
    } catch (error) {
        console.error("绘制游戏时出错:", error);
    }
}

// 绘制墙壁
function drawWalls() {
    for (let row = 0; row < gameMap.length; row++) {
        for (let col = 0; col < gameMap[0].length; col++) {
            if (gameMap[row][col] === 1) {
                const x = col * CELL_SIZE;
                const y = row * CELL_SIZE;
                
                // 使用自定义图像
                if (IMAGES.useCustomArt && IMAGES.loaded && IMAGES.wall) {
                    ctx.drawImage(
                        IMAGES.wall,
                        x,
                        y,
                        CELL_SIZE,
                        CELL_SIZE
                    );
                } else {
                    // 默认绘制方法 - 黑色方块
                    ctx.fillStyle = '#000000';
                    ctx.fillRect(x, y, CELL_SIZE, CELL_SIZE);
                    
                    // 添加简单的3D效果
                    ctx.fillStyle = '#333333';
                    ctx.fillRect(x + 2, y + 2, CELL_SIZE - 4, CELL_SIZE - 4);
                }
            }
        }
    }
}

// 绘制豆子
function drawBeans() {
    beans.forEach(bean => {
        if (bean.active) {
            // 使用自定义图像
            if (IMAGES.useCustomArt && IMAGES.loaded && IMAGES.beans.normal) {
                // 放大豆子尺寸
                const beanSize = 24; // 进一步增加豆子尺寸
                ctx.drawImage(
                    IMAGES.beans.normal,
                    bean.x - beanSize/2,
                    bean.y - beanSize/2,
                    beanSize,
                    beanSize
                );
                return;
            }
            
            // 默认绘制方法 - 在白色背景上使用黑色豆子
            // 创建简单的黑色圆点
            ctx.fillStyle = '#000000';
            ctx.beginPath();
            ctx.arc(bean.x, bean.y, 6, 0, Math.PI * 2);
            ctx.fill();
            
            // 添加小高光
            ctx.fillStyle = '#FFFFFF';
            ctx.beginPath();
            ctx.arc(bean.x - 2, bean.y - 2, 2, 0, Math.PI * 2);
            ctx.fill();
        }
    });
}

// 绘制大豆子
function drawPowerBeans() {
    powerBeans.forEach(bean => {
        if (bean.active) {
            // 使用自定义图像
            if (IMAGES.useCustomArt && IMAGES.loaded && IMAGES.beans.power) {
                // 使用固定大小，不再使用脉动效果
                const beanSize = 40; // 固定大小
                
                ctx.drawImage(
                    IMAGES.beans.power,
                    bean.x - beanSize/2,
                    bean.y - beanSize/2,
                    beanSize,
                    beanSize
                );
                return;
            }
            
            // 默认绘制方法 - 使用黑色大豆子
            const beanSize = 12; // 固定大小
            
            // 黑色圆环
            ctx.strokeStyle = '#000000';
            ctx.lineWidth = 3;
            ctx.beginPath();
            ctx.arc(bean.x, bean.y, beanSize, 0, Math.PI * 2);
            ctx.stroke();
            
            // 内部填充
            ctx.fillStyle = '#000000';
            ctx.beginPath();
            ctx.arc(bean.x, bean.y, beanSize - 4, 0, Math.PI * 2);
            ctx.fill();
            
            // 高光
            ctx.fillStyle = '#FFFFFF';
            ctx.beginPath();
            ctx.arc(bean.x - 3, bean.y - 3, 3, 0, Math.PI * 2);
            ctx.fill();
        }
    });
}

// 绘制吃豆人
function drawPacman() {
    // 确保吃豆人位置有效
    if (!pacman.x || !pacman.y) {
        console.log("吃豆人位置无效:", pacman);
        return;
    }
    
    // 如果吃豆人正在重生闪烁且当前应该隐藏，则不绘制
    if (pacmanRespawning && !pacmanVisible) {
        return;
    }
    
    // 如果吃豆人正在死亡，绘制死亡动画
    if (pacmanDying) {
        drawPacmanDeath();
        return;
    }
    
    // 使用自定义图像
    if (IMAGES.useCustomArt && IMAGES.loaded) {
        let pacmanImg;
        
        // 选择正确的图片
        if (isPowered) {
            pacmanImg = IMAGES.pacman.powered;
        } else {
            switch(pacman.direction) {
                case 'right': pacmanImg = IMAGES.pacman.right; break;
                case 'left': pacmanImg = IMAGES.pacman.left; break;
                case 'up': pacmanImg = IMAGES.pacman.up; break;
                case 'down': pacmanImg = IMAGES.pacman.down; break;
                default: pacmanImg = IMAGES.pacman.right;
            }
        }
        
        // 如果有对应的图片，则绘制图片 - 放大尺寸
        if (pacmanImg) {
            const size = pacman.radius * 3.0; // 进一步放大尺寸
            
            // 当吃豆人吃了红色豆子（isPowered为true）并且向左移动时，水平翻转图片
            if (isPowered && pacman.direction === 'left') {
                ctx.save(); // 保存当前状态
                ctx.translate(pacman.x, pacman.y); // 将原点移到吃豆人中心
                ctx.scale(-1, 1); // 水平翻转
                ctx.drawImage(
                    pacmanImg,
                    -size/2, // 因为已经平移了坐标系，所以使用相对坐标
                    -size/2,
                    size,
                    size
                );
                ctx.restore(); // 恢复之前的状态
            } else {
                ctx.drawImage(
                    pacmanImg,
                    pacman.x - size/2,
                    pacman.y - size/2,
                    size,
                    size
                );
            }
            return;
        }
    }
    
    // 如果没有自定义图像或图像未加载，使用默认绘制方法
    // 计算吃豆人嘴巴的角度
    pacman.mouthOpen += pacman.mouthDir;
    if (pacman.mouthOpen > 0.5 || pacman.mouthOpen < 0.05) {
        pacman.mouthDir *= -1;
    }
    
    // 根据方向确定吃豆人的朝向
    let startAngle = 0;
    let endAngle = 2 * Math.PI;
    
    if (pacman.direction === 'right') {
        startAngle = pacman.mouthOpen * Math.PI;
        endAngle = (2 - pacman.mouthOpen) * Math.PI;
    } else if (pacman.direction === 'left') {
        startAngle = (1 + pacman.mouthOpen) * Math.PI;
        endAngle = (1 - pacman.mouthOpen) * Math.PI;
    } else if (pacman.direction === 'up') {
        startAngle = (1.5 + pacman.mouthOpen) * Math.PI;
        endAngle = (1.5 - pacman.mouthOpen) * Math.PI;
    } else if (pacman.direction === 'down') {
        startAngle = (0.5 + pacman.mouthOpen) * Math.PI;
        endAngle = (0.5 - pacman.mouthOpen) * Math.PI;
    }
    
    // 放大吃豆人尺寸
    const enlargedRadius = pacman.radius * 1.8; // 进一步放大尺寸
    
    // 绘制吃豆人主体 - 黑色轮廓，黄色填充
    ctx.fillStyle = '#FFCC00';
    ctx.strokeStyle = '#000000';
    ctx.lineWidth = 2;
    ctx.beginPath();
    ctx.arc(pacman.x, pacman.y, enlargedRadius, startAngle, endAngle);
    ctx.lineTo(pacman.x, pacman.y);
    ctx.fill();
    ctx.stroke();
    
    // 添加眼睛
    ctx.fillStyle = '#000000';
    const eyeX = pacman.x + (pacman.direction === 'left' ? -5 : 5);
    const eyeY = pacman.y - 10;
    ctx.beginPath();
    ctx.arc(eyeX, eyeY, 3, 0, Math.PI * 2);
    ctx.fill();
}

// 绘制吃豆人死亡动画
function drawPacmanDeath() {
    // 死亡动画：吃豆人逐渐消失，同时产生爆炸效果
    const deathProgress = pacman.deathProgress || 0;
    
    // 绘制爆炸效果
    const explosionRadius = pacman.radius * (1 + deathProgress * 2);
    const opacity = 1 - deathProgress;
    
    // 爆炸外圈
    ctx.strokeStyle = `rgba(0, 0, 0, ${opacity})`;
    ctx.lineWidth = 2;
    ctx.beginPath();
    ctx.arc(pacman.x, pacman.y, explosionRadius, 0, Math.PI * 2);
    ctx.stroke();
    
    // 吃豆人本体逐渐消失
    const pacmanOpacity = 1 - deathProgress;
    const pacmanRadius = pacman.radius * (1 - deathProgress * 0.5);
    
    // 绘制吃豆人主体
    ctx.fillStyle = `rgba(255, 204, 0, ${pacmanOpacity})`;
    ctx.strokeStyle = `rgba(0, 0, 0, ${pacmanOpacity})`;
    ctx.lineWidth = 2;
    ctx.beginPath();
    ctx.arc(pacman.x, pacman.y, pacmanRadius, 0, Math.PI * 2);
    ctx.fill();
    ctx.stroke();
    
    // 添加一些粒子效果
    for (let i = 0; i < 8; i++) {
        const angle = (i / 8) * Math.PI * 2;
        const particleX = pacman.x + Math.cos(angle) * explosionRadius * 0.8;
        const particleY = pacman.y + Math.sin(angle) * explosionRadius * 0.8;
        const particleSize = (1 - deathProgress) * 5;
        
        ctx.fillStyle = `rgba(0, 0, 0, ${opacity})`;
        ctx.beginPath();
        ctx.arc(particleX, particleY, particleSize, 0, Math.PI * 2);
        ctx.fill();
    }
    
    // 更新死亡进度
    pacman.deathProgress = deathProgress + 0.05;
    
    // 当死亡动画完成时
    if (pacman.deathProgress >= 1) {
        pacman.deathProgress = 0;
        pacmanDying = false;
        
        // 直接开始重生，不再有锁定时间
        startPacmanRespawn();
    }
}

// 绘制幽灵
function drawGhost() {
    // 确保幽灵位置有效
    if (!ghost.x || !ghost.y) {
        console.log("幽灵位置无效:", ghost);
        return;
    }
    
    // 定义幽灵半径
    const ghostRadius = CELL_SIZE * 0.65; // 增加幽灵尺寸
    
    // 使用自定义图像
    if (IMAGES.useCustomArt && IMAGES.loaded) {
        let ghostImg;
        
        // 选择正确的图片
        if (ghost.frozen) {
            ghostImg = IMAGES.ghost.frozen;
        } else {
            switch(ghost.direction) {
                case 'right': ghostImg = IMAGES.ghost.right; break;
                case 'left': ghostImg = IMAGES.ghost.left; break;
                case 'up': ghostImg = IMAGES.ghost.up; break;
                case 'down': ghostImg = IMAGES.ghost.down; break;
                default: ghostImg = IMAGES.ghost.right;
            }
        }
        
        // 如果幽灵处于冻结状态，先绘制冰冻效果在图片背后
        if (ghost.frozen) {
            ctx.strokeStyle = '#000000';
            ctx.lineWidth = 2;
            ctx.beginPath();
            ctx.arc(ghost.x, ghost.y, ghostRadius * 1.2, 0, Math.PI * 2);
            ctx.stroke();
        }
        
        // 如果有对应的图片，则绘制图片
        if (ghostImg) {
            // 增加图像大小以使其更加明显
            const size = CELL_SIZE * 1.8; // 增加尺寸
            ctx.drawImage(
                ghostImg,
                ghost.x - size / 2,
                ghost.y - size / 2,
                size,
                size
            );
            
            return;
        }
    }
    
    // 如果没有自定义图像或图像未加载，使用默认绘制方法
    
    // 如果幽灵处于冻结状态，先绘制冰冻效果
    if (ghost.frozen) {
        ctx.strokeStyle = '#000000';
        ctx.lineWidth = 2;
        ctx.setLineDash([5, 5]);
        ctx.beginPath();
        ctx.arc(ghost.x, ghost.y, ghostRadius * 1.2, 0, Math.PI * 2);
        ctx.stroke();
        ctx.setLineDash([]);
    }
    
    // 绘制幽灵身体 - 黑色轮廓，白色填充
    ctx.fillStyle = '#FFFFFF';
    ctx.strokeStyle = '#000000';
    ctx.lineWidth = 2;
    
    // 绘制幽灵上半部分（圆形）
    ctx.beginPath();
    ctx.arc(ghost.x, ghost.y, ghostRadius, Math.PI, 0, false);
    ctx.lineTo(ghost.x + ghostRadius, ghost.y + ghostRadius);
    
    // 绘制波浪底部
    const waveHeight = 7;
    for (let i = 0; i < 3; i++) {
        const waveWidth = ghostRadius / 1.5;
        ctx.lineTo(ghost.x + ghostRadius - waveWidth * (i + 1), ghost.y + ghostRadius - waveHeight);
        ctx.lineTo(ghost.x + ghostRadius - waveWidth * (i + 1) - waveWidth / 2, ghost.y + ghostRadius);
    }
    
    ctx.lineTo(ghost.x - ghostRadius, ghost.y + ghostRadius);
    ctx.lineTo(ghost.x - ghostRadius, ghost.y);
    ctx.fill();
    ctx.stroke();
    
    // 绘制幽灵眼睛
    ctx.fillStyle = '#FFFFFF';
    ctx.strokeStyle = '#000000';
    ctx.lineWidth = 1;
    ctx.beginPath();
    ctx.arc(ghost.x - 4, ghost.y - 3, 5, 0, Math.PI * 2);
    ctx.arc(ghost.x + 4, ghost.y - 3, 5, 0, Math.PI * 2);
    ctx.fill();
    ctx.stroke();
    
    // 绘制幽灵眼珠
    ctx.fillStyle = '#000000';
    ctx.beginPath();
    
    // 根据幽灵方向调整眼珠位置
    let eyeXOffset = 0;
    let eyeYOffset = 0;
    
    if (ghost.direction === 'left') eyeXOffset = -1.5;
    else if (ghost.direction === 'right') eyeXOffset = 1.5;
    else if (ghost.direction === 'up') eyeYOffset = -1.5;
    else if (ghost.direction === 'down') eyeYOffset = 1.5;
    
    ctx.arc(ghost.x - 4 + eyeXOffset, ghost.y - 3 + eyeYOffset, 2.5, 0, Math.PI * 2);
    ctx.arc(ghost.x + 4 + eyeXOffset, ghost.y - 3 + eyeYOffset, 2.5, 0, Math.PI * 2);
    ctx.fill();
}

// 游戏主循环
function gameLoop() {
    if (!gameRunning) return;
    
    // 确保封面图片隐藏
    const gameCover = document.getElementById('gameCover');
    if (gameCover && gameCover.style.display !== 'none') {
        console.log("游戏循环中发现封面图片未隐藏，强制隐藏");
        gameCover.style.display = 'none';
        gameCover.style.visibility = 'hidden';
        gameCover.style.opacity = '0';
    }
    
    // 更新吃豆人位置
    movePacman();
    
    // 检测吃豆人是否吃到豆子
    checkPacmanEatBeans();
    
    // 检测幽灵和吃豆人的碰撞
    checkGhostPacmanCollision();
    
    // 检查游戏是否结束
    checkGameOver();
    
    // 重新绘制游戏
    drawGame();
    
    // 继续游戏循环
    gameLoopId = requestAnimationFrame(gameLoop);
}

// 更新游戏状态
function updateGame() {
    if (!gameRunning) return;
    
    // 更新吃豆人位置
    movePacman();
    
    // 检测吃豆人是否吃到豆子
    checkPacmanEatBeans();
    
    // 检测幽灵和吃豆人的碰撞
    checkGhostPacmanCollision();
    
    // 检查游戏是否结束
    checkGameOver();
    
    // 重新绘制游戏
    drawGame();
    
    // 继续游戏循环
    gameLoopId = requestAnimationFrame(updateGame);
}

// 移动吃豆人
function movePacman() {
    // 如果吃豆人正在死亡或重生中，不移动
    if (pacmanDying || pacmanRespawning) {
        return;
    }
    
    // 如果吃豆人被墙壁阻挡，增加停顿时间
    if (pacman.stuckTimer && pacman.stuckTimer > 0) {
        pacman.stuckTimer--;
        return; // 停顿期间不移动
    }
    
    // 尝试改变方向
    if (pacman.nextDirection !== pacman.direction) {
        const nextRow = Math.floor(pacman.y / CELL_SIZE);
        const nextCol = Math.floor(pacman.x / CELL_SIZE);
        
        // 检查是否可以在当前位置改变方向
        let canChangeDirection = false;
        
        // 确保吃豆人在格子中心位置时才能改变方向
        const centerX = nextCol * CELL_SIZE + CELL_SIZE / 2;
        const centerY = nextRow * CELL_SIZE + CELL_SIZE / 2;
        const distanceToCenter = Math.sqrt(
            Math.pow(pacman.x - centerX, 2) + 
            Math.pow(pacman.y - centerY, 2)
        );
        
        // 如果吃豆人接近格子中心，允许改变方向
        if (distanceToCenter < pacman.speed) {
            // 将吃豆人位置调整到格子中心
            pacman.x = centerX;
            pacman.y = centerY;
            
            // 检查新方向是否可行
            if (pacman.nextDirection === 'up') {
                canChangeDirection = canMove(nextRow - 1, nextCol);
            } else if (pacman.nextDirection === 'down') {
                canChangeDirection = canMove(nextRow + 1, nextCol);
            } else if (pacman.nextDirection === 'left') {
                canChangeDirection = canMove(nextRow, nextCol - 1);
            } else if (pacman.nextDirection === 'right') {
                canChangeDirection = canMove(nextRow, nextCol + 1);
            }
            
            if (canChangeDirection) {
                pacman.direction = pacman.nextDirection;
            }
        }
    }
    
    // 根据当前方向移动吃豆人
    let nextRow = Math.floor(pacman.y / CELL_SIZE);
    let nextCol = Math.floor(pacman.x / CELL_SIZE);
    let willHitWall = false;
    
    if (pacman.direction === 'up') {
        nextRow = Math.floor((pacman.y - pacman.speed) / CELL_SIZE);
        if (canMove(nextRow, nextCol)) {
            pacman.y -= pacman.speed;
        } else {
            willHitWall = true;
        }
    } else if (pacman.direction === 'down') {
        nextRow = Math.floor((pacman.y + pacman.speed) / CELL_SIZE);
        if (canMove(nextRow, nextCol)) {
            pacman.y += pacman.speed;
        } else {
            willHitWall = true;
        }
    } else if (pacman.direction === 'left') {
        nextCol = Math.floor((pacman.x - pacman.speed) / CELL_SIZE);
        if (canMove(nextRow, nextCol)) {
            pacman.x -= pacman.speed;
        } else {
            willHitWall = true;
        }
    } else if (pacman.direction === 'right') {
        nextCol = Math.floor((pacman.x + pacman.speed) / CELL_SIZE);
        if (canMove(nextRow, nextCol)) {
            pacman.x += pacman.speed;
        } else {
            willHitWall = true;
        }
    }
    
    // 如果吃豆人撞墙，设置停顿时间
    if (willHitWall) {
        pacman.stuckTimer = 5; // 设置停顿5帧
    }
    
    // 智能方向改变 - 避免卡在墙角
    smartDirectionChange();
}

// 寻找新的可行方向
function findNewDirection() {
    const currentCol = Math.floor(pacman.x / CELL_SIZE);
    const currentRow = Math.floor(pacman.y / CELL_SIZE);
    
    const possibleDirections = [];
    
    if (canMove(currentRow, currentCol - 1)) possibleDirections.push('left');
    if (canMove(currentRow, currentCol + 1)) possibleDirections.push('right');
    if (canMove(currentRow - 1, currentCol)) possibleDirections.push('up');
    if (canMove(currentRow + 1, currentCol)) possibleDirections.push('down');
    
    if (possibleDirections.length > 0) {
        pacman.nextDirection = possibleDirections[Math.floor(Math.random() * possibleDirections.length)];
    }
}

// 寻找智能方向（优先选择与当前方向不同的方向）
function findSmartDirection() {
    const currentCol = Math.floor(pacman.x / CELL_SIZE);
    const currentRow = Math.floor(pacman.y / CELL_SIZE);
    
    // 获取所有可能的方向
    const possibleDirections = [];
    
    if (canMove(currentRow, currentCol - 1)) possibleDirections.push('left');
    if (canMove(currentRow, currentCol + 1)) possibleDirections.push('right');
    if (canMove(currentRow - 1, currentCol)) possibleDirections.push('up');
    if (canMove(currentRow + 1, currentCol)) possibleDirections.push('down');
    
    if (possibleDirections.length > 0) {
        // 过滤掉当前方向，优先选择新方向
        const newDirections = possibleDirections.filter(dir => dir !== pacman.direction);
        
        if (newDirections.length > 0) {
            // 有新方向可选，随机选择一个
            pacman.nextDirection = newDirections[Math.floor(Math.random() * newDirections.length)];
        } else {
            // 没有新方向，只能选择当前方向
            pacman.nextDirection = possibleDirections[Math.floor(Math.random() * possibleDirections.length)];
        }
    }
}

// 智能方向改变：寻找豆子并避开幽灵
function smartDirectionChange() {
    // 如果吃豆人正在死亡或重生中，不改变方向
    if (pacmanDying || pacmanRespawning) {
        return;
    }
    
    const currentCol = Math.floor(pacman.x / CELL_SIZE);
    const currentRow = Math.floor(pacman.y / CELL_SIZE);
    
    // 计算到幽灵的距离
    const distanceToGhost = Math.sqrt(
        Math.pow(ghost.x - pacman.x, 2) + 
        Math.pow(ghost.y - pacman.y, 2)
    );
    
    // 降低吃豆人躲避幽灵的能力，只有在幽灵非常近时才会尝试逃跑
    if (distanceToGhost < CELL_SIZE * 3) { // 从5减小到3
        // 降低逃跑的概率，增加游戏难度
        if (Math.random() < 0.6) { // 只有60%的概率会逃跑
            // 计算逃跑方向
            const escapeDirections = [];
            
            if (ghost.x < pacman.x && canMove(currentRow, currentCol + 1)) escapeDirections.push('right');
            if (ghost.x > pacman.x && canMove(currentRow, currentCol - 1)) escapeDirections.push('left');
            if (ghost.y < pacman.y && canMove(currentRow + 1, currentCol)) escapeDirections.push('down');
            if (ghost.y > pacman.y && canMove(currentRow - 1, currentCol)) escapeDirections.push('up');
            
            if (escapeDirections.length > 0) {
                pacman.nextDirection = escapeDirections[Math.floor(Math.random() * escapeDirections.length)];
                return;
            }
        }
    }
    
    // 寻找最近的豆子，但不总是选择最近的豆子，增加随机性
    if (Math.random() < 0.7) { // 只有70%的概率会寻找最近的豆子
        let nearestBean = null;
        let minDistance = Infinity;
        
        // 只检查一部分豆子，而不是所有豆子，降低寻路效率
        const maxBeansToCheck = Math.min(beans.length, 15); // 最多检查15个豆子
        const beansToCheck = [];
        
        for (let i = 0; i < maxBeansToCheck; i++) {
            const randomIndex = Math.floor(Math.random() * beans.length);
            if (beans[randomIndex] && beans[randomIndex].active) {
                beansToCheck.push(beans[randomIndex]);
            }
        }
        
        for (const bean of beansToCheck) {
            if (bean.active) {
                const distance = Math.sqrt(
                    Math.pow(bean.x - pacman.x, 2) + 
                    Math.pow(bean.y - pacman.y, 2)
                );
                
                if (distance < minDistance) {
                    minDistance = distance;
                    nearestBean = bean;
                }
            }
        }
        
        // 如果找到最近的豆子，尝试向它移动
        if (nearestBean) {
            // 简单的寻路：尝试向豆子的方向移动，但增加随机性
            const horizontalDistance = nearestBean.x - pacman.x;
            const verticalDistance = nearestBean.y - pacman.y;
            
            // 有时会选择次优路径，增加游戏难度
            if (Math.random() < 0.7) { // 70%的概率选择最优路径
                // 优先选择距离更远的方向
                if (Math.abs(horizontalDistance) > Math.abs(verticalDistance)) {
                    if (horizontalDistance > 0 && canMove(currentRow, currentCol + 1)) {
                        pacman.nextDirection = 'right';
                    } else if (horizontalDistance < 0 && canMove(currentRow, currentCol - 1)) {
                        pacman.nextDirection = 'left';
                    } else if (verticalDistance > 0 && canMove(currentRow + 1, currentCol)) {
                        pacman.nextDirection = 'down';
                    } else if (verticalDistance < 0 && canMove(currentRow - 1, currentCol)) {
                        pacman.nextDirection = 'up';
                    } else {
                        findNewDirection(); // 如果无法直接移动，随机选择一个方向
                    }
                } else {
                    if (verticalDistance > 0 && canMove(currentRow + 1, currentCol)) {
                        pacman.nextDirection = 'down';
                    } else if (verticalDistance < 0 && canMove(currentRow - 1, currentCol)) {
                        pacman.nextDirection = 'up';
                    } else if (horizontalDistance > 0 && canMove(currentRow, currentCol + 1)) {
                        pacman.nextDirection = 'right';
                    } else if (horizontalDistance < 0 && canMove(currentRow, currentCol - 1)) {
                        pacman.nextDirection = 'left';
                    } else {
                        findNewDirection(); // 如果无法直接移动，随机选择一个方向
                    }
                }
            } else {
                // 30%的概率随机选择方向，增加游戏难度
                findNewDirection();
            }
        } else {
            // 如果没有豆子，随机选择一个方向
            findNewDirection();
        }
    } else {
        // 30%的概率完全随机移动，不寻找豆子
        findNewDirection();
    }
}

// 检查是否可以移动到指定位置
function canMove(row, col) {
    if (row < 0 || row >= gameMap.length || col < 0 || col >= gameMap[0].length) {
        return false;
    }
    return gameMap[row][col] !== 1;
}

// 检查是否可以移动到指定位置（带容错）
function canMoveWithTolerance(x, y) {
    // 计算网格位置
    const col = Math.floor(x / CELL_SIZE);
    const row = Math.floor(y / CELL_SIZE);
    
    // 检查是否在地图范围内
    if (row < 0 || row >= gameMap.length || col < 0 || col >= gameMap[0].length) {
        return false;
    }
    
    // 检查是否是墙壁
    return gameMap[row][col] !== 1;
}

// 检测吃豆人是否吃到豆子
function checkPacmanEatBeans() {
    beans.forEach((bean, index) => {
        if (bean.active) {
            const distance = Math.sqrt(
                Math.pow(pacman.x - bean.x, 2) + 
                Math.pow(pacman.y - bean.y, 2)
            );
            
            // 减小检测范围，使吃豆人更难吃到豆子
            if (distance < pacman.radius * 1.2) { // 从1.8减小到1.2
                bean.active = false;
                beansCount--;
                currentGameScore++;
                totalEatenBeans++; // 增加被吃掉的豆子计数
                updateUI();
            }
        }
    });
    
    // 检测吃豆人是否吃到大豆子
    powerBeans.forEach((bean, index) => {
        if (bean.active) {
            const distance = Math.sqrt(
                Math.pow(pacman.x - bean.x, 2) + 
                Math.pow(pacman.y - bean.y, 2)
            );
            
            // 减小检测范围，使吃豆人更难吃到大豆子
            if (distance < pacman.radius * 1.8) { // 从2.5减小到1.8
                bean.active = false;
                totalEatenBeans++; // 增加被吃掉的豆子计数（大豆子也计入）
                activatePowerMode(); // 激活强化模式
            }
        }
    });
}

// 激活强化模式
function activatePowerMode() {
    // 设置吃豆人为强化状态
    isPowered = true;
    
    // 冻结幽灵2秒，减少冻结时间
    ghost.frozen = true;
    if (ghostFreezeTimer) clearTimeout(ghostFreezeTimer);
    ghostFreezeTimer = setTimeout(() => {
        ghost.frozen = false;
    }, 2000); // 从3000减少到2000
    
    // 重置分数
    score += currentGameScore;
    updateUI();
    
    // 3秒后结束强化状态，减少强化时间
    if (powerTimer) clearTimeout(powerTimer);
    powerTimer = setTimeout(() => {
        isPowered = false;
    }, 3000); // 从5000减少到3000
    
    // 显示提示信息
    const powerMessage = document.createElement('div');
    powerMessage.className = 'power-message';
    powerMessage.innerHTML = '<p>强化模式激活！</p><p>幽灵已冻结2秒</p>';
    document.body.appendChild(powerMessage);
    
    // 2秒后移除提示
    setTimeout(() => {
        document.body.removeChild(powerMessage);
    }, 2000);
}

// 检查幽灵与吃豆人的碰撞
function checkGhostPacmanCollision() {
    // 如果吃豆人正在死亡或重生中，不检测碰撞
    if (pacmanDying || pacmanRespawning) {
        return;
    }
    
    const distance = Math.sqrt(
        Math.pow(ghost.x - pacman.x, 2) + 
        Math.pow(ghost.y - pacman.y, 2)
    );
    
    // 如果距离小于一个单元格的大小，则认为发生碰撞
    if (distance < CELL_SIZE * 0.6) { // 缩小碰撞检测范围，从0.8改为0.6
        if (isPowered) {
            // 强化状态下，吃豆人可以反杀幽灵
            // 重置幽灵位置
            ghost.x = 1 * CELL_SIZE + CELL_SIZE / 2;
            ghost.y = 1 * CELL_SIZE + CELL_SIZE / 2;
            ghost.direction = 'right';
        } else {
            // 正常状态下，幽灵抓到吃豆人，得分增加
            currentGameScore++;
            updateUI();
            
            // 开始吃豆人死亡动画
            pacmanDying = true;
            pacman.deathProgress = 0;
            
            // 播放死亡音效（如果有的话）
            // playSound('pacman-death');
            
            // 设置一个延时，在死亡动画结束后重生吃豆人
            setTimeout(() => {
                pacmanDying = false;
                startPacmanRespawn(); // 调用重生函数
                console.log("吃豆人死亡后开始重生");
            }, 1000); // 1秒后重生，与死亡动画时长匹配
        }
    }
}

// 检查游戏是否结束
function checkGameOver() {
    // 如果所有豆子都被吃光，游戏结束
    if (beansCount <= 0) {
        clearInterval(timerInterval);
        timerInterval = null;
        
        // 停止游戏循环
        if (gameLoopId) {
            cancelAnimationFrame(gameLoopId);
            gameLoopId = null;
        }
        
        // 设置游戏状态
        gameRunning = false;
        gameOver = true;
        
        // 确保游戏封面不会显示
        const gameCover = document.getElementById('gameCover');
        if (gameCover) {
            gameCover.style.cssText = "display: none !important; visibility: hidden !important; opacity: 0 !important; z-index: -1 !important;";
            console.log("游戏结束：确保封面图片不显示");
        }
        
        // 计算当前游戏得分（剩余的豆子数量）
        currentGameScore = beansCount;
        
        // 更新总得分
        score += currentGameScore;
        
        // 显示游戏结束弹窗
        const gameOverContent = document.getElementById('gameOverContent');
        if (gameOverContent) {
            gameOverContent.innerHTML = '<h2>失败！</h2><p>所有豆子都被吃光了！</p><p>本局被吃掉豆子: ' + totalEatenBeans + '</p><p>总得分: <span id="finalScore">' + score + '</span></p>';
        }
        
        gameOverElement.style.display = 'flex';
        
        // 检查是否达到得分阈值
        if (score >= SCORE_THRESHOLD && !congratsShown) {
            // 延迟显示恭喜窗口，让玩家先看到游戏结果
            setTimeout(showCongratsMessage, 2000);
        }
    }
}

// 辅助函数：找到幽灵可以移动的最佳方向
function findBestGhostDirection(currentRow, currentCol, currentDirection) {
    // 获取所有可能的方向
    const possibleDirections = [];
    
    // 检查四个方向是否可行
    if (canMove(currentRow - 1, currentCol)) possibleDirections.push('up');
    if (canMove(currentRow + 1, currentCol)) possibleDirections.push('down');
    if (canMove(currentRow, currentCol - 1)) possibleDirections.push('left');
    if (canMove(currentRow, currentCol + 1)) possibleDirections.push('right');
    
    // 如果没有可行方向，返回当前方向
    if (possibleDirections.length === 0) {
        return currentDirection;
    }
    
    // 优先考虑与当前方向相同的方向
    if (possibleDirections.includes(currentDirection)) {
        return currentDirection;
    }
    
    // 避免选择与当前方向相反的方向（除非没有其他选择）
    const oppositeDirection = {
        'up': 'down',
        'down': 'up',
        'left': 'right',
        'right': 'left'
    };
    
    const filteredDirections = possibleDirections.filter(dir => dir !== oppositeDirection[currentDirection]);
    
    // 如果过滤后还有方向可选，从中随机选择一个
    if (filteredDirections.length > 0) {
        return filteredDirections[Math.floor(Math.random() * filteredDirections.length)];
    }
    
    // 如果只剩下相反方向，则选择它
    return possibleDirections[Math.floor(Math.random() * possibleDirections.length)];
}

// 移动幽灵
function moveGhost(direction, speedMultiplier = 1.2) {
    // 如果幽灵被冻结，不能移动
    if (ghost.frozen) return;
    
    // 记录上一次的方向
    ghost.lastDirection = ghost.direction;
    ghost.direction = direction;
    
    // 获取幽灵当前网格位置
    const currentCol = Math.floor(ghost.x / CELL_SIZE);
    const currentRow = Math.floor(ghost.y / CELL_SIZE);
    
    // 计算下一个位置
    let nextX = ghost.x;
    let nextY = ghost.y;
    const moveSpeed = ghost.speed * speedMultiplier;
    
    // 检查前方是否有墙壁
    let wallAhead = false;
    let nextRow = currentRow;
    let nextCol = currentCol;
    
    if (direction === 'left') {
        nextX -= moveSpeed;
        nextCol = Math.floor(nextX / CELL_SIZE);
    } else if (direction === 'right') {
        nextX += moveSpeed;
        nextCol = Math.floor(nextX / CELL_SIZE);
    } else if (direction === 'up') {
        nextY -= moveSpeed;
        nextRow = Math.floor(nextY / CELL_SIZE);
    } else if (direction === 'down') {
        nextY += moveSpeed;
        nextRow = Math.floor(nextY / CELL_SIZE);
    }
    
    // 检查是否会撞墙
    wallAhead = !canMove(nextRow, nextCol);
    
    // 如果前方没有墙壁，正常移动
    if (!wallAhead) {
        ghost.x = nextX;
        ghost.y = nextY;
    } else {
        // 如果会撞墙，尝试自适应转向
        if (direction === 'left' || direction === 'right') {
            // 水平方向撞墙，尝试垂直方向移动
            // 检查上下方向是否可行
            const canMoveUp = canMove(currentRow - 1, currentCol);
            const canMoveDown = canMove(currentRow + 1, currentCol);
            
            // 优先选择与目标方向相邻的路径
            if (canMoveUp && canMoveDown) {
                // 如果上下都可以走，随机选择一个方向
                if (Math.random() < 0.5) {
                    ghost.y -= moveSpeed; // 向上移动
                } else {
                    ghost.y += moveSpeed; // 向下移动
                }
            } else if (canMoveUp) {
                ghost.y -= moveSpeed; // 向上移动
            } else if (canMoveDown) {
                ghost.y += moveSpeed; // 向下移动
            } else {
                // 如果上下都不能走，尝试反向移动
                if (direction === 'left') {
                    ghost.x += moveSpeed; // 向右移动
                    ghost.direction = 'right';
                } else {
                    ghost.x -= moveSpeed; // 向左移动
                    ghost.direction = 'left';
                }
            }
            
            // 检查移动后是否可以恢复原来的方向
            // 如果移动后，原方向不再有墙壁，则在下一次移动时会恢复原方向
        } else {
            // 垂直方向撞墙，尝试水平方向移动
            // 检查左右方向是否可行
            const canMoveLeft = canMove(currentRow, currentCol - 1);
            const canMoveRight = canMove(currentRow, currentCol + 1);
            
            // 优先选择与目标方向相邻的路径
            if (canMoveLeft && canMoveRight) {
                // 如果左右都可以走，随机选择一个方向
                if (Math.random() < 0.5) {
                    ghost.x -= moveSpeed; // 向左移动
                } else {
                    ghost.x += moveSpeed; // 向右移动
                }
            } else if (canMoveLeft) {
                ghost.x -= moveSpeed; // 向左移动
            } else if (canMoveRight) {
                ghost.x += moveSpeed; // 向右移动
            } else {
                // 如果左右都不能走，尝试反向移动
                if (direction === 'up') {
                    ghost.y += moveSpeed; // 向下移动
                    ghost.direction = 'down';
                } else {
                    ghost.y -= moveSpeed; // 向上移动
                    ghost.direction = 'up';
                }
            }
            
            // 检查移动后是否可以恢复原来的方向
            // 如果移动后，原方向不再有墙壁，则在下一次移动时会恢复原方向
        }
    }
    
    // 确保幽灵不会超出边界
    ghost.x = Math.max(CELL_SIZE / 2, Math.min(canvas.width - CELL_SIZE / 2, ghost.x));
    ghost.y = Math.max(CELL_SIZE / 2, Math.min(canvas.height - CELL_SIZE / 2, ghost.y));
    
    // 如果幽灵被卡住，尝试随机移动
    if (Math.abs(ghost.lastX - ghost.x) < 0.5 && Math.abs(ghost.lastY - ghost.y) < 0.5) {
        ghost.stuckCounter = (ghost.stuckCounter || 0) + 1;
        
        // 如果连续多次被卡住，尝试随机移动
        if (ghost.stuckCounter > 3) { // 减少卡住的容忍度
            const directions = ['up', 'down', 'left', 'right'];
            // 移除当前方向，避免继续卡住
            const filteredDirections = directions.filter(dir => dir !== ghost.direction);
            const randomDirection = filteredDirections[Math.floor(Math.random() * filteredDirections.length)];
            ghost.direction = randomDirection;
            ghost.stuckCounter = 0;
            
            // 强制移动一小段距离
            if (randomDirection === 'up') {
                ghost.y -= moveSpeed * 1.5;
            } else if (randomDirection === 'down') {
                ghost.y += moveSpeed * 1.5;
            } else if (randomDirection === 'left') {
                ghost.x -= moveSpeed * 1.5;
            } else if (randomDirection === 'right') {
                ghost.x += moveSpeed * 1.5;
            }
        }
    } else {
        ghost.stuckCounter = 0;
    }
    
    // 记录当前位置，用于检测是否被卡住
    ghost.lastX = ghost.x;
    ghost.lastY = ghost.y;
}

// 键盘事件监听
document.addEventListener('keydown', (event) => {
    if (!gameRunning) return;
    
    // 计算按键间隔，用于加速响应
    const now = Date.now();
    const timeSinceLastPress = now - lastKeyPressTime;
    
    // 根据按键间隔调整速度倍数，按键越快速度越快
    let speedMultiplier = 1.2; // 降低基础速度倍数
    if (timeSinceLastPress < 200) {
        speedMultiplier = 1.5; // 降低加速时的速度倍数
    }
    
    // 根据按键移动幽灵
    switch (event.key) {
        case 'ArrowLeft':
        case 'a':
        case 'A':
            moveGhost('left', speedMultiplier);
            event.preventDefault(); // 防止页面滚动
            break;
        case 'ArrowRight':
        case 'd':
        case 'D':
            moveGhost('right', speedMultiplier);
            event.preventDefault(); // 防止页面滚动
            break;
        case 'ArrowUp':
        case 'w':
        case 'W':
            moveGhost('up', speedMultiplier);
            event.preventDefault(); // 防止页面滚动
            break;
        case 'ArrowDown':
        case 's':
        case 'S':
            moveGhost('down', speedMultiplier);
            event.preventDefault(); // 防止页面滚动
            break;
        // 移除空格键冻结功能
    }
    
    lastKeyPressTime = now;
});

// 开始游戏按钮事件
startButton.addEventListener('click', () => {
    // 调用startGame函数
    startGame();
});

// 重新开始游戏按钮事件
restartButton.addEventListener('click', () => {
    // 调用startGame函数
    startGame();
});

// 启动计时器
function startTimer() {
    // 清除之前的计时器
    if (timerInterval) {
        clearInterval(timerInterval);
    }
    
    // 确保倒计时显示正确
    const timerElement = document.getElementById('timer');
    if (timerElement) {
        timerElement.textContent = gameTimer;
    }
    
    // 重置紧急状态
    const timerDisplay = document.querySelector('.timer-display');
    if (timerDisplay) {
        timerDisplay.classList.remove('urgent');
    }
    
    // 设置新的计时器
    timerInterval = setInterval(() => {
        if (gameRunning) {
            gameTimer--;
            
            // 直接更新倒计时显示
            const timerElement = document.getElementById('timer');
            const timerDisplay = document.querySelector('.timer-display');
            
            if (timerElement) {
                timerElement.textContent = gameTimer;
                
                // 添加视觉效果：当时间少于15秒时闪烁
                if (gameTimer <= 15) {
                    if (timerDisplay) {
                        timerDisplay.classList.add('urgent');
                    }
                    
                    if (gameTimer % 2 === 0) {
                        timerElement.style.color = '#FF0000';
                        timerElement.style.fontSize = '32px';
                    } else {
                        timerElement.style.color = '#FFFFFF';
                        timerElement.style.fontSize = '32px';
                    }
                } else {
                    if (timerDisplay) {
                        timerDisplay.classList.remove('urgent');
                    }
                    
                    timerElement.style.color = '#FF0000';
                    timerElement.style.fontSize = '28px';
                }
            }
            
            // 更新其他UI元素
            updateUI();
            
            // 检查时间是否用完
            if (gameTimer <= 0) {
                checkTimeUp();
            }
        }
    }, 1000);
}

// 检查时间是否用完
function checkTimeUp() {
    clearInterval(timerInterval);
    timerInterval = null;
    
    // 停止游戏循环
    if (gameLoopId) {
        cancelAnimationFrame(gameLoopId);
        gameLoopId = null;
    }
    
    // 设置游戏状态
    gameRunning = false;
    gameOver = true;
    
    // 检查是否吃掉了一半以上的豆子
    const eatenBeans = initialBeansCount - beansCount;
    const halfBeans = initialBeansCount / 2;
    
    // 计算当前游戏得分（剩余的豆子数量）
    currentGameScore = beansCount;
    
    // 更新总得分
    score += currentGameScore;
    
    // 确保游戏封面不会显示
    const gameCover = document.getElementById('gameCover');
    if (gameCover) {
        gameCover.style.cssText = "display: none !important; visibility: hidden !important; opacity: 0 !important; z-index: -1 !important;";
        console.log("游戏时间到：确保封面图片不显示");
    }
    
    // 显示游戏结束弹窗
    const gameOverContent = document.getElementById('gameOverContent');
    if (gameOverContent) {
        if (eatenBeans > halfBeans) {
            // 幽灵输了
            gameOverContent.innerHTML = '<h2>失败！</h2><p>吃豆人吃掉了一半以上的豆子！</p><p>本局被吃掉豆子: ' + totalEatenBeans + '</p><p>总得分: <span id="finalScore">' + score + '</span></p>';
        } else {
            // 幽灵赢了
            gameOverContent.innerHTML = '<h2>胜利！</h2><p>你成功保护了豆子！</p><p>本局保护豆子: ' + currentGameScore + '</p><p>被吃掉豆子: <span id="finalScore">' + totalEatenBeans + '</span></p>';
        }
    }
    
    // 显示游戏结束弹窗
    gameOverElement.style.display = 'flex';
    
    // 检查是否达到得分阈值
    if (score >= SCORE_THRESHOLD && !congratsShown) {
        // 延迟显示恭喜窗口，让玩家先看到游戏结果
        setTimeout(showCongratsMessage, 2000);
    }
    
    // 更新UI
    updateUI();
}

// 显示恭喜窗口
function showCongratsMessage() {
    congratsShown = true;
    congratsMessageElement.style.display = 'block';
}

// 初始化事件监听器
function initEventListeners() {
    // 开始按钮点击事件
    startButton.addEventListener('click', function() {
        console.log("开始按钮被点击");
        startGame();
    });
    
    // 重新开始按钮点击事件
    restartButton.addEventListener('click', function() {
        console.log("重新开始按钮被点击");
        startGame();
    });
    
    // 游戏结束弹窗关闭按钮点击事件
    const closeGameOver = document.getElementById('closeGameOver');
    if (closeGameOver) {
        closeGameOver.addEventListener('click', function() {
            const gameOver = document.getElementById('gameOver');
            if (gameOver) {
                gameOver.style.display = 'none';
            }
        });
    }
    
    // 游戏结束弹窗中的重新开始按钮点击事件
    const gameOverRestartButton = document.getElementById('gameOverRestartButton');
    if (gameOverRestartButton) {
        gameOverRestartButton.addEventListener('click', function() {
            console.log("游戏结束弹窗中的重新开始按钮被点击");
            const gameOver = document.getElementById('gameOver');
            if (gameOver) {
                gameOver.style.display = 'none';
            }
            startGame();
        });
    }
    
    // 恭喜窗口关闭按钮点击事件
    congratsCloseButton.addEventListener('click', function() {
        congratsMessageElement.style.display = 'none';
    });
    
    // 关于游戏按钮点击事件
    const aboutButton = document.getElementById('aboutButton');
    const aboutModal = document.getElementById('aboutModal');
    const closeAboutModal = document.getElementById('closeAboutModal');
    
    if (aboutButton && aboutModal && closeAboutModal) {
        // 点击关于游戏按钮显示弹窗
        aboutButton.addEventListener('click', function() {
            aboutModal.style.display = 'flex';
        });
        
        // 点击关闭按钮隐藏弹窗
        closeAboutModal.addEventListener('click', function() {
            aboutModal.style.display = 'none';
        });
        
        // 点击弹窗外部区域隐藏弹窗
        aboutModal.addEventListener('click', function(event) {
            if (event.target === aboutModal) {
                aboutModal.style.display = 'none';
            }
        });
    }
    
    // 键盘事件监听
    document.addEventListener('keydown', function(event) {
        // 只有在游戏运行时才响应键盘事件
        if (!gameRunning) return;
        
        // 方向键控制
        if (event.key === 'ArrowUp' || event.key === 'w' || event.key === 'W') {
            moveGhost('up', 1.2);
        } else if (event.key === 'ArrowDown' || event.key === 's' || event.key === 'S') {
            moveGhost('down', 1.2);
        } else if (event.key === 'ArrowLeft' || event.key === 'a' || event.key === 'A') {
            moveGhost('left', 1.2);
        } else if (event.key === 'ArrowRight' || event.key === 'd' || event.key === 'D') {
            moveGhost('right', 1.2);
        }
        // 移除空格键冻结功能
    });
    
    // 移动设备触摸控制
    const upBtn = document.getElementById('upBtn');
    const downBtn = document.getElementById('downBtn');
    const leftBtn = document.getElementById('leftBtn');
    const rightBtn = document.getElementById('rightBtn');
    
    if (upBtn && downBtn && leftBtn && rightBtn) {
        console.log("找到移动控制按钮，添加事件监听器");
        
        // 为每个按钮同时添加触摸和点击事件
        const addControlEvents = (btn, direction) => {
            // 触摸事件
            btn.addEventListener('touchstart', function(e) {
                e.preventDefault();
                console.log("触摸按钮:", direction);
                moveGhost(direction, 1.2);
            });
            
            // 点击事件 (用于非触摸设备)
            btn.addEventListener('click', function(e) {
                console.log("点击按钮:", direction);
                moveGhost(direction, 1.2);
            });
        };
        
        // 添加事件监听器
        addControlEvents(upBtn, 'up');
        addControlEvents(downBtn, 'down');
        addControlEvents(leftBtn, 'left');
        addControlEvents(rightBtn, 'right');
    } else {
        console.warn("未找到一个或多个移动控制按钮");
    }
    
    // 监听窗口大小变化
    window.addEventListener('resize', resizeGame);
}


// 不再立即绘制游戏，而是等待用户点击开始按钮
// drawGame();

// 添加调试信息
console.log("游戏初始化完成，画布尺寸:", canvas.width, "x", canvas.height);
console.log("吃豆人位置:", pacman.x, pacman.y);
console.log("幽灵位置:", ghost.x, ghost.y);

// 开始吃豆人重生闪烁效果
function startPacmanRespawn() {
    // 重置吃豆人位置到地图中央，确保是有效位置
    const pacmanStartRow = 8; // 使用与初始化相同的位置
    const pacmanStartCol = 10;
    
    console.log("尝试重生吃豆人到位置:", pacmanStartRow, pacmanStartCol);
    
    // 确保重生位置是有效的（不是墙壁）
    if (gameMap[pacmanStartRow] && gameMap[pacmanStartRow][pacmanStartCol] !== 1) {
        pacman.x = pacmanStartCol * CELL_SIZE + CELL_SIZE / 2;
        pacman.y = pacmanStartRow * CELL_SIZE + CELL_SIZE / 2;
        console.log("吃豆人重生到原始位置:", pacman.x, pacman.y);
    } else {
        // 如果原始位置无效，寻找一个远离幽灵的有效位置
        let bestRow = -1;
        let bestCol = -1;
        let maxDistance = 0;
        
        // 获取幽灵当前位置的网格坐标
        const ghostRow = Math.floor(ghost.y / CELL_SIZE);
        const ghostCol = Math.floor(ghost.x / CELL_SIZE);
        
        // 遍历地图寻找最远的有效位置
        for (let row = 0; row < gameMap.length; row++) {
            for (let col = 0; col < gameMap[0].length; col++) {
                if (gameMap[row][col] !== 1) { // 不是墙壁
                    // 计算到幽灵的距离
                    const distance = Math.sqrt(
                        Math.pow(row - ghostRow, 2) + 
                        Math.pow(col - ghostCol, 2)
                    );
                    
                    // 如果这个位置比之前找到的更远，更新最佳位置
                    if (distance > maxDistance) {
                        maxDistance = distance;
                        bestRow = row;
                        bestCol = col;
                    }
                }
            }
        }
        
        // 如果找到了有效位置，使用它
        if (bestRow >= 0 && bestCol >= 0) {
            pacman.x = bestCol * CELL_SIZE + CELL_SIZE / 2;
            pacman.y = bestRow * CELL_SIZE + CELL_SIZE / 2;
            console.log("找到远离幽灵的重生位置:", bestRow, bestCol, "坐标:", pacman.x, pacman.y, "距离:", maxDistance);
        } else {
            // 如果没有找到有效位置（极少数情况），使用地图中心
            pacman.x = Math.floor(gameMap[0].length / 2) * CELL_SIZE + CELL_SIZE / 2;
            pacman.y = Math.floor(gameMap.length / 2) * CELL_SIZE + CELL_SIZE / 2;
            console.log("使用地图中心作为重生位置:", pacman.x, pacman.y);
        }
    }
    
    pacman.direction = 'left';
    pacman.nextDirection = 'left';
    pacman.stuckTimer = 10; // 重生后增加停顿时间
    
    pacmanRespawning = true;
    pacmanVisible = true;
    
    // 清除之前的闪烁计时器
    if (respawnBlinkTimer) {
        clearInterval(respawnBlinkTimer);
    }
    
    // 设置闪烁效果，每100毫秒切换一次可见性
    let blinkCount = 0;
    respawnBlinkTimer = setInterval(() => {
        pacmanVisible = !pacmanVisible;
        blinkCount++;
        
        // 2秒后停止闪烁（每100毫秒切换一次，共20次）
        if (blinkCount >= 20) {
            clearInterval(respawnBlinkTimer);
            pacmanRespawning = false;
            pacmanVisible = true;
            console.log("吃豆人重生完成，最终位置:", pacman.x, pacman.y);
        }
    }, 100);
}

// 冻结幽灵
function freezeGhost(duration = 3000) {
    if (!ghost.frozen) {
        ghost.frozen = true;
        ghost.originalSpeed = ghost.speed;
        ghost.speed = ghost.speed * 0.5; // 减慢速度
        
        // 添加视觉效果
        const ghostElement = document.createElement('div');
        ghostElement.className = 'ghost-freeze-effect';
        ghostElement.style.position = 'absolute';
        ghostElement.style.left = `${ghost.x}px`;
        ghostElement.style.top = `${ghost.y}px`;
        ghostElement.style.width = `${CELL_SIZE * 2}px`;
        ghostElement.style.height = `${CELL_SIZE * 2}px`;
        ghostElement.style.backgroundColor = 'rgba(255, 182, 193, 0.5)';
        ghostElement.style.borderRadius = '50%';
        ghostElement.style.transform = 'translate(-50%, -50%)';
        ghostElement.style.animation = 'pulse 1s infinite alternate';
        document.querySelector('.game-view').appendChild(ghostElement);
        
        // 设置定时器解除冻结状态
        setTimeout(() => {
            ghost.frozen = false;
            ghost.speed = ghost.originalSpeed;
            
            // 移除视觉效果
            if (ghostElement.parentNode) {
                ghostElement.parentNode.removeChild(ghostElement);
            }
        }, duration);
    }
}

// 开始游戏
function startGame() {
    console.log("开始游戏函数被调用");
    
    // 立即隐藏游戏封面 - 在所有操作之前
    const gameCover = document.getElementById('gameCover');
    if (gameCover) {
        // 使用多种方式确保封面隐藏
        gameCover.style.cssText = "display: none !important; visibility: hidden !important; opacity: 0 !important; z-index: -1 !important;";
        console.log("游戏开始：立即隐藏封面图片 - 使用cssText");
    }
    
    // 先设置游戏状态为运行中，这样initGame不会显示封面
    gameRunning = true;
    gameOver = false;
    
    // 确保取消之前的动画帧
    if (gameLoopId) {
        cancelAnimationFrame(gameLoopId);
        gameLoopId = null;
    }
    
    // 确保gameScale已初始化
    if (typeof gameScale === 'undefined') {
        gameScale = 1;
    }
    
    // 重置并重新初始化游戏
    initGame();
    
    // 重新设置游戏状态为运行中
    gameRunning = true;
    gameOver = false;
    
    // 更新UI元素
    startButton.style.display = 'none';
    restartButton.style.display = 'block';
    gameOverElement.style.display = 'none';
    
    // 重置并启动计时器
    gameTimer = GAME_TIME;
    updateUI();
    startTimer();
    
    // 再次确认封面图片隐藏
    if (gameCover) {
        gameCover.style.cssText = "display: none !important; visibility: hidden !important; opacity: 0 !important; z-index: -1 !important;";
        console.log("游戏开始：再次确认隐藏封面图片");
    }
    
    // 调整游戏大小以适应屏幕
    resizeGame();
    
    // 开始绘制游戏
    drawGame();
    
    // 开始游戏循环
    gameLoopId = requestAnimationFrame(gameLoop);
    
    // 强制重绘DOM以确保变更生效
    setTimeout(() => {
        if (gameCover) {
            console.log("延迟检查封面状态:", {
                cssText: gameCover.style.cssText,
                computedDisplay: window.getComputedStyle(gameCover).display,
                computedVisibility: window.getComputedStyle(gameCover).visibility,
                computedOpacity: window.getComputedStyle(gameCover).opacity
            });
            
            // 再次确认封面已隐藏
            if (window.getComputedStyle(gameCover).display !== 'none') {
                console.log("封面仍未隐藏，使用更强力的方法");
                // 尝试移除元素
                gameCover.parentNode.removeChild(gameCover);
            }
        }
        
        // 再次调整大小
        resizeGame();
    }, 100);
}

// 调整游戏大小以适应屏幕
function resizeGame() {
    const gameContainer = document.querySelector('.game-container');
    const gameView = document.querySelector('.game-view');
    const canvasElement = document.getElementById('gameCanvas');
    
    if (!gameContainer || !gameView || !canvasElement) {
        console.error("找不到必要的DOM元素");
        return;
    }
    
    // 获取容器宽度
    const containerWidth = gameContainer.clientWidth;
    
    // 确保gameScale已初始化
    if (typeof gameScale === 'undefined') {
        gameScale = 1;
        console.log("resizeGame: 初始化gameScale为1");
    }
    
    // 计算缩放比例
    gameScale = containerWidth / (COLS * CELL_SIZE);
    
    console.log("调整游戏大小 - 容器宽度:", containerWidth, "缩放比例:", gameScale);
    
    // 如果是小屏幕设备，调整画布大小
    if (window.innerWidth <= 820) {
        // 保持宽高比
        const scaledHeight = ROWS * CELL_SIZE * gameScale;
        
        // 设置画布样式
        canvasElement.style.width = `${containerWidth}px`;
        canvasElement.style.height = `${scaledHeight}px`;
        
        console.log("小屏幕适配 - 设置画布尺寸:", containerWidth, "x", scaledHeight);
        
        // 显示移动控制按钮
        const mobileControls = document.querySelector('.mobile-controls');
        if (mobileControls) {
            mobileControls.style.display = 'flex';
        }
    } else {
        // 重置为原始大小
        canvasElement.style.width = '';
        canvasElement.style.height = '';
        
        console.log("大屏幕适配 - 重置画布尺寸为原始大小");
        
        // 隐藏移动控制按钮
        const mobileControls = document.querySelector('.mobile-controls');
        if (mobileControls) {
            mobileControls.style.display = 'none';
        }
    }
    
    // 确保画布内容清晰
    canvasElement.width = COLS * CELL_SIZE;
    canvasElement.height = ROWS * CELL_SIZE;
    
    // 重绘游戏
    if (gameRunning) {
        console.log("游戏运行中，重新绘制");
        drawGame();
    } else {
        console.log("游戏未运行，绘制初始画面");
        // 绘制初始画面
        ctx.clearRect(0, 0, canvas.width, canvas.height);
        ctx.fillStyle = '#FFFFFF';
        ctx.fillRect(0, 0, canvas.width, canvas.height);
        
        // 如果游戏地图已初始化，绘制墙壁
        if (gameMap && gameMap.length > 0) {
            drawWalls();
        }
    }
}
